// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g 2010-12-01 14:22:26

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;

using Antlr.Runtime.Tree;

namespace  RSD.Scripting 
{
public partial class ScorBotScriptParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"INT", 
		"CRLF", 
		"ID", 
		"STRING", 
		"CR", 
		"LF", 
		"COMMENT", 
		"TAB", 
		"WS", 
		"ESC_SEQ", 
		"'REPEAT_START'", 
		"'REPEAT_END'", 
		"'HOME'", 
		"'INIT'", 
		"'MOVE'", 
		"'MOVE_C'", 
		"'WAIT_FOR_CONVEYOR'", 
		"'MEASURE_JAW'", 
		"'MEASURE_WEIGHT'", 
		"'MOVE_SORT'", 
		"'ROLL'", 
		"'STOP'", 
		"'OPEN_GRIPPER'", 
		"'CLOSE_GRIPPER'"
    };

    public const int T__27 = 27;
    public const int T__26 = 26;
    public const int T__25 = 25;
    public const int T__24 = 24;
    public const int CRLF = 5;
    public const int T__23 = 23;
    public const int T__22 = 22;
    public const int T__21 = 21;
    public const int T__20 = 20;
    public const int TAB = 11;
    public const int INT = 4;
    public const int ID = 6;
    public const int EOF = -1;
    public const int T__19 = 19;
    public const int ESC_SEQ = 13;
    public const int WS = 12;
    public const int T__16 = 16;
    public const int T__15 = 15;
    public const int T__18 = 18;
    public const int T__17 = 17;
    public const int T__14 = 14;
    public const int COMMENT = 10;
    public const int CR = 8;
    public const int STRING = 7;
    public const int LF = 9;

    // delegates
    // delegators



        public ScorBotScriptParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public ScorBotScriptParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();
            this.state.ruleMemo = new Hashtable[29+1];
             
             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return ScorBotScriptParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g"; }
    }


        public new void ReportError(RecognitionException e) 
        {
            throw e;
        }


    public class program_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "program"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:32:1: program : ( robotExpression )* ;
    public ScorBotScriptParser.program_return program() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.program_return retval = new ScorBotScriptParser.program_return();
        retval.Start = input.LT(1);
        int program_StartIndex = input.Index();
        CommonTree root_0 = null;

        ScorBotScriptParser.robotExpression_return robotExpression1 = default(ScorBotScriptParser.robotExpression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 1) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:33:5: ( ( robotExpression )* )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:33:7: ( robotExpression )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:33:7: ( robotExpression )*
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == 14 || (LA1_0 >= 16 && LA1_0 <= 27)) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:33:8: robotExpression
            			    {
            			    	PushFollow(FOLLOW_robotExpression_in_program131);
            			    	robotExpression1 = robotExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, robotExpression1.Tree);

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 1, program_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "program"

    public class robotExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "robotExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:36:1: robotExpression : ( homeExpression | initExpression | moveVectorExpression | moveCoordinatesExpression | waitForConveyorExpression | rollExpression | stopExpression | openGripperExpression | closeGripperExpression | measureJawExpression | measureWeightExpression | repeatExpression | moveSortExpression );
    public ScorBotScriptParser.robotExpression_return robotExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.robotExpression_return retval = new ScorBotScriptParser.robotExpression_return();
        retval.Start = input.LT(1);
        int robotExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        ScorBotScriptParser.homeExpression_return homeExpression2 = default(ScorBotScriptParser.homeExpression_return);

        ScorBotScriptParser.initExpression_return initExpression3 = default(ScorBotScriptParser.initExpression_return);

        ScorBotScriptParser.moveVectorExpression_return moveVectorExpression4 = default(ScorBotScriptParser.moveVectorExpression_return);

        ScorBotScriptParser.moveCoordinatesExpression_return moveCoordinatesExpression5 = default(ScorBotScriptParser.moveCoordinatesExpression_return);

        ScorBotScriptParser.waitForConveyorExpression_return waitForConveyorExpression6 = default(ScorBotScriptParser.waitForConveyorExpression_return);

        ScorBotScriptParser.rollExpression_return rollExpression7 = default(ScorBotScriptParser.rollExpression_return);

        ScorBotScriptParser.stopExpression_return stopExpression8 = default(ScorBotScriptParser.stopExpression_return);

        ScorBotScriptParser.openGripperExpression_return openGripperExpression9 = default(ScorBotScriptParser.openGripperExpression_return);

        ScorBotScriptParser.closeGripperExpression_return closeGripperExpression10 = default(ScorBotScriptParser.closeGripperExpression_return);

        ScorBotScriptParser.measureJawExpression_return measureJawExpression11 = default(ScorBotScriptParser.measureJawExpression_return);

        ScorBotScriptParser.measureWeightExpression_return measureWeightExpression12 = default(ScorBotScriptParser.measureWeightExpression_return);

        ScorBotScriptParser.repeatExpression_return repeatExpression13 = default(ScorBotScriptParser.repeatExpression_return);

        ScorBotScriptParser.moveSortExpression_return moveSortExpression14 = default(ScorBotScriptParser.moveSortExpression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 2) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:37:5: ( homeExpression | initExpression | moveVectorExpression | moveCoordinatesExpression | waitForConveyorExpression | rollExpression | stopExpression | openGripperExpression | closeGripperExpression | measureJawExpression | measureWeightExpression | repeatExpression | moveSortExpression )
            int alt2 = 13;
            switch ( input.LA(1) ) 
            {
            case 16:
            	{
                alt2 = 1;
                }
                break;
            case 17:
            	{
                alt2 = 2;
                }
                break;
            case 18:
            	{
                alt2 = 3;
                }
                break;
            case 19:
            	{
                alt2 = 4;
                }
                break;
            case 20:
            	{
                alt2 = 5;
                }
                break;
            case 24:
            	{
                alt2 = 6;
                }
                break;
            case 25:
            	{
                alt2 = 7;
                }
                break;
            case 26:
            	{
                alt2 = 8;
                }
                break;
            case 27:
            	{
                alt2 = 9;
                }
                break;
            case 21:
            	{
                alt2 = 10;
                }
                break;
            case 22:
            	{
                alt2 = 11;
                }
                break;
            case 14:
            	{
                alt2 = 12;
                }
                break;
            case 23:
            	{
                alt2 = 13;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:37:7: homeExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_homeExpression_in_robotExpression150);
                    	homeExpression2 = homeExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, homeExpression2.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:38:7: initExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_initExpression_in_robotExpression158);
                    	initExpression3 = initExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, initExpression3.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:39:7: moveVectorExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_moveVectorExpression_in_robotExpression166);
                    	moveVectorExpression4 = moveVectorExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, moveVectorExpression4.Tree);

                    }
                    break;
                case 4 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:40:7: moveCoordinatesExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_moveCoordinatesExpression_in_robotExpression175);
                    	moveCoordinatesExpression5 = moveCoordinatesExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, moveCoordinatesExpression5.Tree);

                    }
                    break;
                case 5 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:41:7: waitForConveyorExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_waitForConveyorExpression_in_robotExpression183);
                    	waitForConveyorExpression6 = waitForConveyorExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, waitForConveyorExpression6.Tree);

                    }
                    break;
                case 6 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:42:7: rollExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_rollExpression_in_robotExpression191);
                    	rollExpression7 = rollExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rollExpression7.Tree);

                    }
                    break;
                case 7 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:43:7: stopExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_stopExpression_in_robotExpression200);
                    	stopExpression8 = stopExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, stopExpression8.Tree);

                    }
                    break;
                case 8 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:44:7: openGripperExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_openGripperExpression_in_robotExpression209);
                    	openGripperExpression9 = openGripperExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, openGripperExpression9.Tree);

                    }
                    break;
                case 9 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:45:7: closeGripperExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_closeGripperExpression_in_robotExpression218);
                    	closeGripperExpression10 = closeGripperExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, closeGripperExpression10.Tree);

                    }
                    break;
                case 10 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:46:7: measureJawExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_measureJawExpression_in_robotExpression226);
                    	measureJawExpression11 = measureJawExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, measureJawExpression11.Tree);

                    }
                    break;
                case 11 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:47:7: measureWeightExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_measureWeightExpression_in_robotExpression234);
                    	measureWeightExpression12 = measureWeightExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, measureWeightExpression12.Tree);

                    }
                    break;
                case 12 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:48:7: repeatExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_repeatExpression_in_robotExpression242);
                    	repeatExpression13 = repeatExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, repeatExpression13.Tree);

                    }
                    break;
                case 13 :
                    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:49:7: moveSortExpression
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_moveSortExpression_in_robotExpression250);
                    	moveSortExpression14 = moveSortExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, moveSortExpression14.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 2, robotExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "robotExpression"

    public class repeatExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "repeatExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:52:1: repeatExpression : 'REPEAT_START' INT CRLF ( robotExpression )* 'REPEAT_END' CRLF ;
    public ScorBotScriptParser.repeatExpression_return repeatExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.repeatExpression_return retval = new ScorBotScriptParser.repeatExpression_return();
        retval.Start = input.LT(1);
        int repeatExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal15 = null;
        IToken INT16 = null;
        IToken CRLF17 = null;
        IToken string_literal19 = null;
        IToken CRLF20 = null;
        ScorBotScriptParser.robotExpression_return robotExpression18 = default(ScorBotScriptParser.robotExpression_return);


        CommonTree string_literal15_tree=null;
        CommonTree INT16_tree=null;
        CommonTree CRLF17_tree=null;
        CommonTree string_literal19_tree=null;
        CommonTree CRLF20_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 3) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:53:5: ( 'REPEAT_START' INT CRLF ( robotExpression )* 'REPEAT_END' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:53:7: 'REPEAT_START' INT CRLF ( robotExpression )* 'REPEAT_END' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal15=(IToken)Match(input,14,FOLLOW_14_in_repeatExpression267); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal15_tree = (CommonTree)adaptor.Create(string_literal15);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal15_tree, root_0);
            	}
            	INT16=(IToken)Match(input,INT,FOLLOW_INT_in_repeatExpression270); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{INT16_tree = (CommonTree)adaptor.Create(INT16);
            		adaptor.AddChild(root_0, INT16_tree);
            	}
            	CRLF17=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_repeatExpression272); if (state.failed) return retval;
            	// C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:53:33: ( robotExpression )*
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0 == 14 || (LA3_0 >= 16 && LA3_0 <= 27)) )
            	    {
            	        alt3 = 1;
            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:53:34: robotExpression
            			    {
            			    	PushFollow(FOLLOW_robotExpression_in_repeatExpression276);
            			    	robotExpression18 = robotExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, robotExpression18.Tree);

            			    }
            			    break;

            			default:
            			    goto loop3;
            	    }
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements

            	string_literal19=(IToken)Match(input,15,FOLLOW_15_in_repeatExpression280); if (state.failed) return retval;
            	CRLF20=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_repeatExpression283); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 3, repeatExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "repeatExpression"

    public class homeExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "homeExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:56:1: homeExpression : 'HOME' axis= ID CRLF ;
    public ScorBotScriptParser.homeExpression_return homeExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.homeExpression_return retval = new ScorBotScriptParser.homeExpression_return();
        retval.Start = input.LT(1);
        int homeExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken axis = null;
        IToken string_literal21 = null;
        IToken CRLF22 = null;

        CommonTree axis_tree=null;
        CommonTree string_literal21_tree=null;
        CommonTree CRLF22_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 4) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:57:5: ( 'HOME' axis= ID CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:57:7: 'HOME' axis= ID CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal21=(IToken)Match(input,16,FOLLOW_16_in_homeExpression301); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal21_tree = (CommonTree)adaptor.Create(string_literal21);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal21_tree, root_0);
            	}
            	axis=(IToken)Match(input,ID,FOLLOW_ID_in_homeExpression306); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{axis_tree = (CommonTree)adaptor.Create(axis);
            		adaptor.AddChild(root_0, axis_tree);
            	}
            	CRLF22=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_homeExpression308); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 4, homeExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "homeExpression"

    public class initExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "initExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:60:1: initExpression : 'INIT' CRLF ;
    public ScorBotScriptParser.initExpression_return initExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.initExpression_return retval = new ScorBotScriptParser.initExpression_return();
        retval.Start = input.LT(1);
        int initExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal23 = null;
        IToken CRLF24 = null;

        CommonTree string_literal23_tree=null;
        CommonTree CRLF24_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 5) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:61:5: ( 'INIT' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:61:7: 'INIT' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal23=(IToken)Match(input,17,FOLLOW_17_in_initExpression326); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal23_tree = (CommonTree)adaptor.Create(string_literal23);
            		adaptor.AddChild(root_0, string_literal23_tree);
            	}
            	CRLF24=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_initExpression328); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 5, initExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "initExpression"

    public class moveVectorExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "moveVectorExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:64:1: moveVectorExpression : 'MOVE' vector= STRING CRLF ;
    public ScorBotScriptParser.moveVectorExpression_return moveVectorExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.moveVectorExpression_return retval = new ScorBotScriptParser.moveVectorExpression_return();
        retval.Start = input.LT(1);
        int moveVectorExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken vector = null;
        IToken string_literal25 = null;
        IToken CRLF26 = null;

        CommonTree vector_tree=null;
        CommonTree string_literal25_tree=null;
        CommonTree CRLF26_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 6) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:65:5: ( 'MOVE' vector= STRING CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:65:7: 'MOVE' vector= STRING CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal25=(IToken)Match(input,18,FOLLOW_18_in_moveVectorExpression346); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal25_tree = (CommonTree)adaptor.Create(string_literal25);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal25_tree, root_0);
            	}
            	vector=(IToken)Match(input,STRING,FOLLOW_STRING_in_moveVectorExpression351); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{vector_tree = (CommonTree)adaptor.Create(vector);
            		adaptor.AddChild(root_0, vector_tree);
            	}
            	CRLF26=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_moveVectorExpression353); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 6, moveVectorExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "moveVectorExpression"

    public class moveCoordinatesExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "moveCoordinatesExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:68:1: moveCoordinatesExpression : 'MOVE_C' x= INT y= INT z= INT pitch= INT roll= INT CRLF ;
    public ScorBotScriptParser.moveCoordinatesExpression_return moveCoordinatesExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.moveCoordinatesExpression_return retval = new ScorBotScriptParser.moveCoordinatesExpression_return();
        retval.Start = input.LT(1);
        int moveCoordinatesExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken x = null;
        IToken y = null;
        IToken z = null;
        IToken pitch = null;
        IToken roll = null;
        IToken string_literal27 = null;
        IToken CRLF28 = null;

        CommonTree x_tree=null;
        CommonTree y_tree=null;
        CommonTree z_tree=null;
        CommonTree pitch_tree=null;
        CommonTree roll_tree=null;
        CommonTree string_literal27_tree=null;
        CommonTree CRLF28_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 7) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:69:5: ( 'MOVE_C' x= INT y= INT z= INT pitch= INT roll= INT CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:69:7: 'MOVE_C' x= INT y= INT z= INT pitch= INT roll= INT CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal27=(IToken)Match(input,19,FOLLOW_19_in_moveCoordinatesExpression372); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal27_tree = (CommonTree)adaptor.Create(string_literal27);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal27_tree, root_0);
            	}
            	x=(IToken)Match(input,INT,FOLLOW_INT_in_moveCoordinatesExpression377); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{x_tree = (CommonTree)adaptor.Create(x);
            		adaptor.AddChild(root_0, x_tree);
            	}
            	y=(IToken)Match(input,INT,FOLLOW_INT_in_moveCoordinatesExpression381); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{y_tree = (CommonTree)adaptor.Create(y);
            		adaptor.AddChild(root_0, y_tree);
            	}
            	z=(IToken)Match(input,INT,FOLLOW_INT_in_moveCoordinatesExpression385); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{z_tree = (CommonTree)adaptor.Create(z);
            		adaptor.AddChild(root_0, z_tree);
            	}
            	pitch=(IToken)Match(input,INT,FOLLOW_INT_in_moveCoordinatesExpression389); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{pitch_tree = (CommonTree)adaptor.Create(pitch);
            		adaptor.AddChild(root_0, pitch_tree);
            	}
            	roll=(IToken)Match(input,INT,FOLLOW_INT_in_moveCoordinatesExpression393); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{roll_tree = (CommonTree)adaptor.Create(roll);
            		adaptor.AddChild(root_0, roll_tree);
            	}
            	CRLF28=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_moveCoordinatesExpression395); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 7, moveCoordinatesExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "moveCoordinatesExpression"

    public class waitForConveyorExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "waitForConveyorExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:72:1: waitForConveyorExpression : 'WAIT_FOR_CONVEYOR' CRLF ;
    public ScorBotScriptParser.waitForConveyorExpression_return waitForConveyorExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.waitForConveyorExpression_return retval = new ScorBotScriptParser.waitForConveyorExpression_return();
        retval.Start = input.LT(1);
        int waitForConveyorExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal29 = null;
        IToken CRLF30 = null;

        CommonTree string_literal29_tree=null;
        CommonTree CRLF30_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 8) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:73:5: ( 'WAIT_FOR_CONVEYOR' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:73:7: 'WAIT_FOR_CONVEYOR' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal29=(IToken)Match(input,20,FOLLOW_20_in_waitForConveyorExpression413); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal29_tree = (CommonTree)adaptor.Create(string_literal29);
            		adaptor.AddChild(root_0, string_literal29_tree);
            	}
            	CRLF30=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_waitForConveyorExpression415); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 8, waitForConveyorExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "waitForConveyorExpression"

    public class measureJawExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "measureJawExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:76:1: measureJawExpression : 'MEASURE_JAW' field= STRING CRLF ;
    public ScorBotScriptParser.measureJawExpression_return measureJawExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.measureJawExpression_return retval = new ScorBotScriptParser.measureJawExpression_return();
        retval.Start = input.LT(1);
        int measureJawExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken field = null;
        IToken string_literal31 = null;
        IToken CRLF32 = null;

        CommonTree field_tree=null;
        CommonTree string_literal31_tree=null;
        CommonTree CRLF32_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 9) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:77:5: ( 'MEASURE_JAW' field= STRING CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:77:7: 'MEASURE_JAW' field= STRING CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal31=(IToken)Match(input,21,FOLLOW_21_in_measureJawExpression433); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal31_tree = (CommonTree)adaptor.Create(string_literal31);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal31_tree, root_0);
            	}
            	field=(IToken)Match(input,STRING,FOLLOW_STRING_in_measureJawExpression438); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{field_tree = (CommonTree)adaptor.Create(field);
            		adaptor.AddChild(root_0, field_tree);
            	}
            	CRLF32=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_measureJawExpression440); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 9, measureJawExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "measureJawExpression"

    public class measureWeightExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "measureWeightExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:80:1: measureWeightExpression : 'MEASURE_WEIGHT' CRLF ;
    public ScorBotScriptParser.measureWeightExpression_return measureWeightExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.measureWeightExpression_return retval = new ScorBotScriptParser.measureWeightExpression_return();
        retval.Start = input.LT(1);
        int measureWeightExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal33 = null;
        IToken CRLF34 = null;

        CommonTree string_literal33_tree=null;
        CommonTree CRLF34_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 10) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:81:5: ( 'MEASURE_WEIGHT' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:81:7: 'MEASURE_WEIGHT' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal33=(IToken)Match(input,22,FOLLOW_22_in_measureWeightExpression458); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal33_tree = (CommonTree)adaptor.Create(string_literal33);
            		adaptor.AddChild(root_0, string_literal33_tree);
            	}
            	CRLF34=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_measureWeightExpression460); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 10, measureWeightExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "measureWeightExpression"

    public class moveSortExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "moveSortExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:84:1: moveSortExpression : 'MOVE_SORT' CRLF ;
    public ScorBotScriptParser.moveSortExpression_return moveSortExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.moveSortExpression_return retval = new ScorBotScriptParser.moveSortExpression_return();
        retval.Start = input.LT(1);
        int moveSortExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal35 = null;
        IToken CRLF36 = null;

        CommonTree string_literal35_tree=null;
        CommonTree CRLF36_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 11) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:85:5: ( 'MOVE_SORT' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:85:7: 'MOVE_SORT' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal35=(IToken)Match(input,23,FOLLOW_23_in_moveSortExpression478); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal35_tree = (CommonTree)adaptor.Create(string_literal35);
            		adaptor.AddChild(root_0, string_literal35_tree);
            	}
            	CRLF36=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_moveSortExpression480); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 11, moveSortExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "moveSortExpression"

    public class rollExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "rollExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:88:1: rollExpression : 'ROLL' speed= INT CRLF ;
    public ScorBotScriptParser.rollExpression_return rollExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.rollExpression_return retval = new ScorBotScriptParser.rollExpression_return();
        retval.Start = input.LT(1);
        int rollExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken speed = null;
        IToken string_literal37 = null;
        IToken CRLF38 = null;

        CommonTree speed_tree=null;
        CommonTree string_literal37_tree=null;
        CommonTree CRLF38_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 12) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:89:5: ( 'ROLL' speed= INT CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:89:7: 'ROLL' speed= INT CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal37=(IToken)Match(input,24,FOLLOW_24_in_rollExpression498); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal37_tree = (CommonTree)adaptor.Create(string_literal37);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal37_tree, root_0);
            	}
            	speed=(IToken)Match(input,INT,FOLLOW_INT_in_rollExpression503); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{speed_tree = (CommonTree)adaptor.Create(speed);
            		adaptor.AddChild(root_0, speed_tree);
            	}
            	CRLF38=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_rollExpression505); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 12, rollExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "rollExpression"

    public class stopExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "stopExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:92:1: stopExpression : 'STOP' axis= ID CRLF ;
    public ScorBotScriptParser.stopExpression_return stopExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.stopExpression_return retval = new ScorBotScriptParser.stopExpression_return();
        retval.Start = input.LT(1);
        int stopExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken axis = null;
        IToken string_literal39 = null;
        IToken CRLF40 = null;

        CommonTree axis_tree=null;
        CommonTree string_literal39_tree=null;
        CommonTree CRLF40_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:93:5: ( 'STOP' axis= ID CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:93:7: 'STOP' axis= ID CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal39=(IToken)Match(input,25,FOLLOW_25_in_stopExpression523); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal39_tree = (CommonTree)adaptor.Create(string_literal39);
            		root_0 = (CommonTree)adaptor.BecomeRoot(string_literal39_tree, root_0);
            	}
            	axis=(IToken)Match(input,ID,FOLLOW_ID_in_stopExpression528); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{axis_tree = (CommonTree)adaptor.Create(axis);
            		adaptor.AddChild(root_0, axis_tree);
            	}
            	CRLF40=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_stopExpression530); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 13, stopExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "stopExpression"

    public class openGripperExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "openGripperExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:96:1: openGripperExpression : 'OPEN_GRIPPER' CRLF ;
    public ScorBotScriptParser.openGripperExpression_return openGripperExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.openGripperExpression_return retval = new ScorBotScriptParser.openGripperExpression_return();
        retval.Start = input.LT(1);
        int openGripperExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal41 = null;
        IToken CRLF42 = null;

        CommonTree string_literal41_tree=null;
        CommonTree CRLF42_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 14) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:97:5: ( 'OPEN_GRIPPER' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:97:7: 'OPEN_GRIPPER' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal41=(IToken)Match(input,26,FOLLOW_26_in_openGripperExpression548); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal41_tree = (CommonTree)adaptor.Create(string_literal41);
            		adaptor.AddChild(root_0, string_literal41_tree);
            	}
            	CRLF42=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_openGripperExpression550); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 14, openGripperExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "openGripperExpression"

    public class closeGripperExpression_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "closeGripperExpression"
    // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:100:1: closeGripperExpression : 'CLOSE_GRIPPER' CRLF ;
    public ScorBotScriptParser.closeGripperExpression_return closeGripperExpression() // throws RecognitionException [1]
    {   
        ScorBotScriptParser.closeGripperExpression_return retval = new ScorBotScriptParser.closeGripperExpression_return();
        retval.Start = input.LT(1);
        int closeGripperExpression_StartIndex = input.Index();
        CommonTree root_0 = null;

        IToken string_literal43 = null;
        IToken CRLF44 = null;

        CommonTree string_literal43_tree=null;
        CommonTree CRLF44_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 15) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:101:5: ( 'CLOSE_GRIPPER' CRLF )
            // C:\\Users\\Windcape\\Visual Studio 2010\\Projects\\I4PRJ4\\trunk\\December\\RobotSorterDeluxe\\RSD.Scripting\\ScorBotScript.g:101:7: 'CLOSE_GRIPPER' CRLF
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	string_literal43=(IToken)Match(input,27,FOLLOW_27_in_closeGripperExpression568); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal43_tree = (CommonTree)adaptor.Create(string_literal43);
            		adaptor.AddChild(root_0, string_literal43_tree);
            	}
            	CRLF44=(IToken)Match(input,CRLF,FOLLOW_CRLF_in_closeGripperExpression570); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 15, closeGripperExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "closeGripperExpression"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_robotExpression_in_program131 = new BitSet(new ulong[]{0x000000000FFF4002UL});
    public static readonly BitSet FOLLOW_homeExpression_in_robotExpression150 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_initExpression_in_robotExpression158 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_moveVectorExpression_in_robotExpression166 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_moveCoordinatesExpression_in_robotExpression175 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_waitForConveyorExpression_in_robotExpression183 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_rollExpression_in_robotExpression191 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_stopExpression_in_robotExpression200 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_openGripperExpression_in_robotExpression209 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_closeGripperExpression_in_robotExpression218 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_measureJawExpression_in_robotExpression226 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_measureWeightExpression_in_robotExpression234 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_repeatExpression_in_robotExpression242 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_moveSortExpression_in_robotExpression250 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_14_in_repeatExpression267 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_repeatExpression270 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_repeatExpression272 = new BitSet(new ulong[]{0x000000000FFFC000UL});
    public static readonly BitSet FOLLOW_robotExpression_in_repeatExpression276 = new BitSet(new ulong[]{0x000000000FFFC000UL});
    public static readonly BitSet FOLLOW_15_in_repeatExpression280 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_repeatExpression283 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_16_in_homeExpression301 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_homeExpression306 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_homeExpression308 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_17_in_initExpression326 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_initExpression328 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_18_in_moveVectorExpression346 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_STRING_in_moveVectorExpression351 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_moveVectorExpression353 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_19_in_moveCoordinatesExpression372 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_moveCoordinatesExpression377 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_moveCoordinatesExpression381 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_moveCoordinatesExpression385 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_moveCoordinatesExpression389 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_moveCoordinatesExpression393 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_moveCoordinatesExpression395 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_20_in_waitForConveyorExpression413 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_waitForConveyorExpression415 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_21_in_measureJawExpression433 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_STRING_in_measureJawExpression438 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_measureJawExpression440 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_22_in_measureWeightExpression458 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_measureWeightExpression460 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_23_in_moveSortExpression478 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_moveSortExpression480 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_24_in_rollExpression498 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_INT_in_rollExpression503 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_rollExpression505 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_25_in_stopExpression523 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_stopExpression528 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_stopExpression530 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_26_in_openGripperExpression548 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_openGripperExpression550 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_27_in_closeGripperExpression568 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_CRLF_in_closeGripperExpression570 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}